sdk/samples/all in on code/Visual Studio 2010/CSEnumerateAppDomains/Program.cs

   1 /****************************** Module Header ******************************\
   2 * Module Name:  Program.cs
   3 * Project:          CSEnumerateAppDomains
   4 * Copyright (c) Microsoft Corporation.
   5 *
   6 * This source file is used to handle the input command. If this application
   7 * starts with an argument, process the command directly and then exit, else
   8 * show the help text to let user choose a command.
   9 *
  10 * This source is subject to the Microsoft Public License.
  11 * See http://www.microsoft.com/opensource/licenses.mspx#Ms-PL.
  12 * All other rights reserved.
  13 *
  14 * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
  15 * EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
  16 * WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
  17 \***************************************************************************/
  18
  19 using System;
  20 using Microsoft.Samples.Debugging.CorDebug;
  21
  22 namespace CSEnumerateAppDomains
  23 {
  24     class Program
  25     {
  26         static void Main(string[] args)
  27         {
  28
  29             // Create new AppDomain in current process.
  30             AppDomain.CreateDomain("Hello world!");
  31
  32             try
  33             {
  34                 // If this application starts without any argument, show the help text to
  35                 // let user choose a command.
  36                 if (args.Length == 0)
  37                 {
  38                     // Application will not exit until user types the exit command.
  39                     // If the command is not correct, it will show the help text in the
  40                     // next loop.
  41                     while (true)
  42                     {
  43                         Console.WriteLine(@"
  44 Please choose a command:
  45 1: Show AppDomains in current process.
  46 2: List all managed processes.
  47 3: Show help text.
  48 4: Exit this application.
  49 To show the AppDomains in a specified process, please type ""PID"" and
  50 the ID of the process directly, like PID1234.
  51 ");
  52
  53                         string cmd = Console.ReadLine();
  54                         int cmdID = 0;
  55                         if (int.TryParse(cmd, out cmdID))
  56                         {
  57                             switch (cmdID)
  58                             {
  59                                 case 1:
  60                                     ProcessCommand("CurrentProcess");
  61                                     break;
  62                                 case 2:
  63                                     ProcessCommand("ListAllManagedProcesses");
  64                                     break;
  65                                 case 4:
  66                                     Environment.Exit(0);
  67                                     break;
  68                                 default:
  69
  70                                     // Show the help text in the next loop.
  71                                     break;
  72
  73                             }
  74                         }
  75                         else if (cmd.StartsWith("PID", StringComparison.OrdinalIgnoreCase))
  76                         {
  77                             ProcessCommand(cmd);
  78                         }
  79
  80                     }
  81                 }
  82                 else if (args.Length == 1)
  83                 {
  84                     ProcessCommand(args[0]);
  85                 }
  86             }
  87             catch (Exception ex)
  88             {
  89                 Console.WriteLine(ex.Message);
  90
  91                 // The exit code 100 means that this application does not run successfully.
  92                 Environment.Exit(100);
  93             }
  94         }
  95
  96         static void ProcessCommand(string arg)
  97         {
  98             // List AppDomains in current process.
  99             if (arg.Equals("CurrentProcess", StringComparison.OrdinalIgnoreCase))
 100             {
 101                 Console.WriteLine("List AppDomains in current process...");
 102                 ShowAppDomainsInCurrentProcess();
 103             }
 104
 105             // List all managed processes.
 106             else if (arg.Equals("ListAllManagedProcesses", StringComparison.OrdinalIgnoreCase))
 107             {
 108                 Console.WriteLine("List all managed processes...");
 109                 ListAllManagedProcesses();
 110             }
 111
 112             // Show the AppDomains in a specified process, arg must starts with "PID".
 113             else if (arg.StartsWith("PID", StringComparison.OrdinalIgnoreCase))
 114             {
 115                 int pid = 0;
 116                 int.TryParse(arg.Substring(3), out pid);
 117                 Console.WriteLine(string.Format(
 118                     "List AppDomains in the process {0} ...", pid));
 119                 ShowAppDomains(pid);
 120             }
 121
 122             else
 123             {
 124                 throw new ArgumentException("Please type a valid command.");
 125             }
 126
 127         }
 128
 129         /// <summary>
 130         /// Show AppDomains in Current Process.
 131         /// </summary>
 132         static void ShowAppDomainsInCurrentProcess()
 133         {
 134
 135             // GetAppDomainsInCurrentProcess is a static method of the class ManagedProcess.
 136             // This method is used to get all AppDomains in Current Process.
 137             var appDomains = ManagedProcess.GetAppDomainsInCurrentProcess();
 138
 139             foreach (var appDomain in appDomains)
 140             {
 141                 Console.WriteLine("AppDomain Id={0}, Name={1}",
 142                     appDomain.Id, appDomain.FriendlyName);
 143             }
 144         }
 145
 146         /// <summary>
 147         /// Show AppDomains in a specified process.
 148         /// </summary>
 149         /// <param name="pid"> The ID of the Process.</param>
 150         static void ShowAppDomains(int pid)
 151         {
 152             if (pid <= 0)
 153             {
 154                 throw new ArgumentException("Please type a valid PID.");
 155             }
 156
 157             ManagedProcess process = null;
 158             try
 159             {
 160                 // GetManagedProcessByID is a static method of the class ManagedProcess.
 161                 // This method is used to get an instance of ManagedProcessInfo. If there is
 162                 // no managed process with this PID, an ArgumentException will be thrown.
 163                 process = ManagedProcess.GetManagedProcessByID(pid);
 164
 165                 foreach (CorAppDomain appDomain in process.AppDomains)
 166                 {
 167                     Console.WriteLine("AppDomain Id={0}, Name={1}",
 168                         appDomain.Id,
 169                         appDomain.Name);
 170                 }
 171
 172             }
 173             catch (ArgumentException _argumentException)
 174             {
 175                 Console.WriteLine(_argumentException.Message);
 176             }
 177             catch (ApplicationException _applicationException)
 178             {
 179                 Console.WriteLine(_applicationException.Message);
 180             }
 181             catch (Exception ex)
 182             {
 183                 Console.WriteLine(ex.Message);
 184                 Console.WriteLine(ex.GetType());
 185                 Console.WriteLine(ex.StackTrace);
 186                 Console.WriteLine("Cannot get the process. "
 187                    + " Make sure the process exists and it's a managed process");
 188             }
 189             finally
 190             {
 191                 if (process != null)
 192                 {
 193                     process.Dispose();
 194                 }
 195             }
 196         }
 197
 198         /// <summary>
 199         /// List all managed processes.
 200         /// </summary>
 201         static void ListAllManagedProcesses()
 202         {
 203
 204             // GetManagedProcesses is a static method of the class ManagedProcess.
 205             // This method is used to get a list that contains all managed processes
 206             // in current machine.
 207             var processes = ManagedProcess.GetManagedProcesses();
 208
 209             foreach (var process in processes)
 210             {
 211                 Console.WriteLine("ID={0}\tName={1}",
 212                      process.ProcessID, process.ProcessName);
 213                 Console.Write("Loaded Runtimes: ");
 214                 foreach (var runtime in process.LoadedRuntimes)
 215                 {
 216                     Console.Write(runtime.GetVersionString() + "\t");
 217                 }
 218                 Console.WriteLine("\n");
 219             }
 220
 221         }
 222
 223     }
 224 }